Termination w.r.t. Q of the following Term Rewriting System could not be shown:

Q restricted rewrite system:
The TRS R consists of the following rules:

and2(true, y) -> y
and2(false, y) -> false
eq2(nil, nil) -> true
eq2(cons2(t, l), nil) -> false
eq2(nil, cons2(t, l)) -> false
eq2(cons2(t, l), cons2(t', l')) -> and2(eq2(t, t'), eq2(l, l'))
eq2(var1(l), var1(l')) -> eq2(l, l')
eq2(var1(l), apply2(t, s)) -> false
eq2(var1(l), lambda2(x, t)) -> false
eq2(apply2(t, s), var1(l)) -> false
eq2(apply2(t, s), apply2(t', s')) -> and2(eq2(t, t'), eq2(s, s'))
eq2(apply2(t, s), lambda2(x, t)) -> false
eq2(lambda2(x, t), var1(l)) -> false
eq2(lambda2(x, t), apply2(t, s)) -> false
eq2(lambda2(x, t), lambda2(x', t')) -> and2(eq2(x, x'), eq2(t, t'))
if3(true, var1(k), var1(l')) -> var1(k)
if3(false, var1(k), var1(l')) -> var1(l')
ren3(var1(l), var1(k), var1(l')) -> if3(eq2(l, l'), var1(k), var1(l'))
ren3(x, y, apply2(t, s)) -> apply2(ren3(x, y, t), ren3(x, y, s))
ren3(x, y, lambda2(z, t)) -> lambda2(var1(cons2(x, cons2(y, cons2(lambda2(z, t), nil)))), ren3(x, y, ren3(z, var1(cons2(x, cons2(y, cons2(lambda2(z, t), nil)))), t)))

Q is empty.


QTRS
  ↳ DependencyPairsProof

Q restricted rewrite system:
The TRS R consists of the following rules:

and2(true, y) -> y
and2(false, y) -> false
eq2(nil, nil) -> true
eq2(cons2(t, l), nil) -> false
eq2(nil, cons2(t, l)) -> false
eq2(cons2(t, l), cons2(t', l')) -> and2(eq2(t, t'), eq2(l, l'))
eq2(var1(l), var1(l')) -> eq2(l, l')
eq2(var1(l), apply2(t, s)) -> false
eq2(var1(l), lambda2(x, t)) -> false
eq2(apply2(t, s), var1(l)) -> false
eq2(apply2(t, s), apply2(t', s')) -> and2(eq2(t, t'), eq2(s, s'))
eq2(apply2(t, s), lambda2(x, t)) -> false
eq2(lambda2(x, t), var1(l)) -> false
eq2(lambda2(x, t), apply2(t, s)) -> false
eq2(lambda2(x, t), lambda2(x', t')) -> and2(eq2(x, x'), eq2(t, t'))
if3(true, var1(k), var1(l')) -> var1(k)
if3(false, var1(k), var1(l')) -> var1(l')
ren3(var1(l), var1(k), var1(l')) -> if3(eq2(l, l'), var1(k), var1(l'))
ren3(x, y, apply2(t, s)) -> apply2(ren3(x, y, t), ren3(x, y, s))
ren3(x, y, lambda2(z, t)) -> lambda2(var1(cons2(x, cons2(y, cons2(lambda2(z, t), nil)))), ren3(x, y, ren3(z, var1(cons2(x, cons2(y, cons2(lambda2(z, t), nil)))), t)))

Q is empty.

Using Dependency Pairs [1,13] we result in the following initial DP problem:
Q DP problem:
The TRS P consists of the following rules:

EQ2(var1(l), var1(l')) -> EQ2(l, l')
REN3(x, y, apply2(t, s)) -> REN3(x, y, t)
EQ2(apply2(t, s), apply2(t', s')) -> EQ2(t, t')
EQ2(lambda2(x, t), lambda2(x', t')) -> EQ2(x, x')
EQ2(cons2(t, l), cons2(t', l')) -> EQ2(l, l')
EQ2(apply2(t, s), apply2(t', s')) -> AND2(eq2(t, t'), eq2(s, s'))
EQ2(cons2(t, l), cons2(t', l')) -> EQ2(t, t')
REN3(var1(l), var1(k), var1(l')) -> EQ2(l, l')
EQ2(lambda2(x, t), lambda2(x', t')) -> AND2(eq2(x, x'), eq2(t, t'))
EQ2(cons2(t, l), cons2(t', l')) -> AND2(eq2(t, t'), eq2(l, l'))
REN3(x, y, lambda2(z, t)) -> REN3(x, y, ren3(z, var1(cons2(x, cons2(y, cons2(lambda2(z, t), nil)))), t))
EQ2(lambda2(x, t), lambda2(x', t')) -> EQ2(t, t')
EQ2(apply2(t, s), apply2(t', s')) -> EQ2(s, s')
REN3(var1(l), var1(k), var1(l')) -> IF3(eq2(l, l'), var1(k), var1(l'))
REN3(x, y, lambda2(z, t)) -> REN3(z, var1(cons2(x, cons2(y, cons2(lambda2(z, t), nil)))), t)
REN3(x, y, apply2(t, s)) -> REN3(x, y, s)

The TRS R consists of the following rules:

and2(true, y) -> y
and2(false, y) -> false
eq2(nil, nil) -> true
eq2(cons2(t, l), nil) -> false
eq2(nil, cons2(t, l)) -> false
eq2(cons2(t, l), cons2(t', l')) -> and2(eq2(t, t'), eq2(l, l'))
eq2(var1(l), var1(l')) -> eq2(l, l')
eq2(var1(l), apply2(t, s)) -> false
eq2(var1(l), lambda2(x, t)) -> false
eq2(apply2(t, s), var1(l)) -> false
eq2(apply2(t, s), apply2(t', s')) -> and2(eq2(t, t'), eq2(s, s'))
eq2(apply2(t, s), lambda2(x, t)) -> false
eq2(lambda2(x, t), var1(l)) -> false
eq2(lambda2(x, t), apply2(t, s)) -> false
eq2(lambda2(x, t), lambda2(x', t')) -> and2(eq2(x, x'), eq2(t, t'))
if3(true, var1(k), var1(l')) -> var1(k)
if3(false, var1(k), var1(l')) -> var1(l')
ren3(var1(l), var1(k), var1(l')) -> if3(eq2(l, l'), var1(k), var1(l'))
ren3(x, y, apply2(t, s)) -> apply2(ren3(x, y, t), ren3(x, y, s))
ren3(x, y, lambda2(z, t)) -> lambda2(var1(cons2(x, cons2(y, cons2(lambda2(z, t), nil)))), ren3(x, y, ren3(z, var1(cons2(x, cons2(y, cons2(lambda2(z, t), nil)))), t)))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

↳ QTRS
  ↳ DependencyPairsProof
QDP
      ↳ DependencyGraphProof

Q DP problem:
The TRS P consists of the following rules:

EQ2(var1(l), var1(l')) -> EQ2(l, l')
REN3(x, y, apply2(t, s)) -> REN3(x, y, t)
EQ2(apply2(t, s), apply2(t', s')) -> EQ2(t, t')
EQ2(lambda2(x, t), lambda2(x', t')) -> EQ2(x, x')
EQ2(cons2(t, l), cons2(t', l')) -> EQ2(l, l')
EQ2(apply2(t, s), apply2(t', s')) -> AND2(eq2(t, t'), eq2(s, s'))
EQ2(cons2(t, l), cons2(t', l')) -> EQ2(t, t')
REN3(var1(l), var1(k), var1(l')) -> EQ2(l, l')
EQ2(lambda2(x, t), lambda2(x', t')) -> AND2(eq2(x, x'), eq2(t, t'))
EQ2(cons2(t, l), cons2(t', l')) -> AND2(eq2(t, t'), eq2(l, l'))
REN3(x, y, lambda2(z, t)) -> REN3(x, y, ren3(z, var1(cons2(x, cons2(y, cons2(lambda2(z, t), nil)))), t))
EQ2(lambda2(x, t), lambda2(x', t')) -> EQ2(t, t')
EQ2(apply2(t, s), apply2(t', s')) -> EQ2(s, s')
REN3(var1(l), var1(k), var1(l')) -> IF3(eq2(l, l'), var1(k), var1(l'))
REN3(x, y, lambda2(z, t)) -> REN3(z, var1(cons2(x, cons2(y, cons2(lambda2(z, t), nil)))), t)
REN3(x, y, apply2(t, s)) -> REN3(x, y, s)

The TRS R consists of the following rules:

and2(true, y) -> y
and2(false, y) -> false
eq2(nil, nil) -> true
eq2(cons2(t, l), nil) -> false
eq2(nil, cons2(t, l)) -> false
eq2(cons2(t, l), cons2(t', l')) -> and2(eq2(t, t'), eq2(l, l'))
eq2(var1(l), var1(l')) -> eq2(l, l')
eq2(var1(l), apply2(t, s)) -> false
eq2(var1(l), lambda2(x, t)) -> false
eq2(apply2(t, s), var1(l)) -> false
eq2(apply2(t, s), apply2(t', s')) -> and2(eq2(t, t'), eq2(s, s'))
eq2(apply2(t, s), lambda2(x, t)) -> false
eq2(lambda2(x, t), var1(l)) -> false
eq2(lambda2(x, t), apply2(t, s)) -> false
eq2(lambda2(x, t), lambda2(x', t')) -> and2(eq2(x, x'), eq2(t, t'))
if3(true, var1(k), var1(l')) -> var1(k)
if3(false, var1(k), var1(l')) -> var1(l')
ren3(var1(l), var1(k), var1(l')) -> if3(eq2(l, l'), var1(k), var1(l'))
ren3(x, y, apply2(t, s)) -> apply2(ren3(x, y, t), ren3(x, y, s))
ren3(x, y, lambda2(z, t)) -> lambda2(var1(cons2(x, cons2(y, cons2(lambda2(z, t), nil)))), ren3(x, y, ren3(z, var1(cons2(x, cons2(y, cons2(lambda2(z, t), nil)))), t)))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [13,14,18] contains 2 SCCs with 5 less nodes.

↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
QDP
            ↳ QDPOrderProof
          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

EQ2(var1(l), var1(l')) -> EQ2(l, l')
EQ2(apply2(t, s), apply2(t', s')) -> EQ2(t, t')
EQ2(lambda2(x, t), lambda2(x', t')) -> EQ2(x, x')
EQ2(cons2(t, l), cons2(t', l')) -> EQ2(l, l')
EQ2(lambda2(x, t), lambda2(x', t')) -> EQ2(t, t')
EQ2(apply2(t, s), apply2(t', s')) -> EQ2(s, s')
EQ2(cons2(t, l), cons2(t', l')) -> EQ2(t, t')

The TRS R consists of the following rules:

and2(true, y) -> y
and2(false, y) -> false
eq2(nil, nil) -> true
eq2(cons2(t, l), nil) -> false
eq2(nil, cons2(t, l)) -> false
eq2(cons2(t, l), cons2(t', l')) -> and2(eq2(t, t'), eq2(l, l'))
eq2(var1(l), var1(l')) -> eq2(l, l')
eq2(var1(l), apply2(t, s)) -> false
eq2(var1(l), lambda2(x, t)) -> false
eq2(apply2(t, s), var1(l)) -> false
eq2(apply2(t, s), apply2(t', s')) -> and2(eq2(t, t'), eq2(s, s'))
eq2(apply2(t, s), lambda2(x, t)) -> false
eq2(lambda2(x, t), var1(l)) -> false
eq2(lambda2(x, t), apply2(t, s)) -> false
eq2(lambda2(x, t), lambda2(x', t')) -> and2(eq2(x, x'), eq2(t, t'))
if3(true, var1(k), var1(l')) -> var1(k)
if3(false, var1(k), var1(l')) -> var1(l')
ren3(var1(l), var1(k), var1(l')) -> if3(eq2(l, l'), var1(k), var1(l'))
ren3(x, y, apply2(t, s)) -> apply2(ren3(x, y, t), ren3(x, y, s))
ren3(x, y, lambda2(z, t)) -> lambda2(var1(cons2(x, cons2(y, cons2(lambda2(z, t), nil)))), ren3(x, y, ren3(z, var1(cons2(x, cons2(y, cons2(lambda2(z, t), nil)))), t)))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].


The following pairs can be oriented strictly and are deleted.


EQ2(lambda2(x, t), lambda2(x', t')) -> EQ2(x, x')
EQ2(lambda2(x, t), lambda2(x', t')) -> EQ2(t, t')
The remaining pairs can at least be oriented weakly.

EQ2(var1(l), var1(l')) -> EQ2(l, l')
EQ2(apply2(t, s), apply2(t', s')) -> EQ2(t, t')
EQ2(cons2(t, l), cons2(t', l')) -> EQ2(l, l')
EQ2(apply2(t, s), apply2(t', s')) -> EQ2(s, s')
EQ2(cons2(t, l), cons2(t', l')) -> EQ2(t, t')
Used ordering: Polynomial interpretation [21]:

POL(EQ2(x1, x2)) = 1 + x1·x2   
POL(apply2(x1, x2)) = x1 + x2   
POL(cons2(x1, x2)) = x1 + x1·x2 + x2   
POL(lambda2(x1, x2)) = 1 + x1 + x2   
POL(var1(x1)) = x1   

The following usable rules [14] were oriented: none



↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
            ↳ QDPOrderProof
QDP
                ↳ QDPOrderProof
          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

EQ2(var1(l), var1(l')) -> EQ2(l, l')
EQ2(apply2(t, s), apply2(t', s')) -> EQ2(t, t')
EQ2(cons2(t, l), cons2(t', l')) -> EQ2(l, l')
EQ2(cons2(t, l), cons2(t', l')) -> EQ2(t, t')
EQ2(apply2(t, s), apply2(t', s')) -> EQ2(s, s')

The TRS R consists of the following rules:

and2(true, y) -> y
and2(false, y) -> false
eq2(nil, nil) -> true
eq2(cons2(t, l), nil) -> false
eq2(nil, cons2(t, l)) -> false
eq2(cons2(t, l), cons2(t', l')) -> and2(eq2(t, t'), eq2(l, l'))
eq2(var1(l), var1(l')) -> eq2(l, l')
eq2(var1(l), apply2(t, s)) -> false
eq2(var1(l), lambda2(x, t)) -> false
eq2(apply2(t, s), var1(l)) -> false
eq2(apply2(t, s), apply2(t', s')) -> and2(eq2(t, t'), eq2(s, s'))
eq2(apply2(t, s), lambda2(x, t)) -> false
eq2(lambda2(x, t), var1(l)) -> false
eq2(lambda2(x, t), apply2(t, s)) -> false
eq2(lambda2(x, t), lambda2(x', t')) -> and2(eq2(x, x'), eq2(t, t'))
if3(true, var1(k), var1(l')) -> var1(k)
if3(false, var1(k), var1(l')) -> var1(l')
ren3(var1(l), var1(k), var1(l')) -> if3(eq2(l, l'), var1(k), var1(l'))
ren3(x, y, apply2(t, s)) -> apply2(ren3(x, y, t), ren3(x, y, s))
ren3(x, y, lambda2(z, t)) -> lambda2(var1(cons2(x, cons2(y, cons2(lambda2(z, t), nil)))), ren3(x, y, ren3(z, var1(cons2(x, cons2(y, cons2(lambda2(z, t), nil)))), t)))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].


The following pairs can be oriented strictly and are deleted.


EQ2(cons2(t, l), cons2(t', l')) -> EQ2(l, l')
EQ2(cons2(t, l), cons2(t', l')) -> EQ2(t, t')
The remaining pairs can at least be oriented weakly.

EQ2(var1(l), var1(l')) -> EQ2(l, l')
EQ2(apply2(t, s), apply2(t', s')) -> EQ2(t, t')
EQ2(apply2(t, s), apply2(t', s')) -> EQ2(s, s')
Used ordering: Polynomial interpretation [21]:

POL(EQ2(x1, x2)) = 1 + x1·x2   
POL(apply2(x1, x2)) = x1 + x2   
POL(cons2(x1, x2)) = 1 + x1 + x1·x2 + x2   
POL(var1(x1)) = x1   

The following usable rules [14] were oriented: none



↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
            ↳ QDPOrderProof
              ↳ QDP
                ↳ QDPOrderProof
QDP
                    ↳ QDPOrderProof
          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

EQ2(var1(l), var1(l')) -> EQ2(l, l')
EQ2(apply2(t, s), apply2(t', s')) -> EQ2(t, t')
EQ2(apply2(t, s), apply2(t', s')) -> EQ2(s, s')

The TRS R consists of the following rules:

and2(true, y) -> y
and2(false, y) -> false
eq2(nil, nil) -> true
eq2(cons2(t, l), nil) -> false
eq2(nil, cons2(t, l)) -> false
eq2(cons2(t, l), cons2(t', l')) -> and2(eq2(t, t'), eq2(l, l'))
eq2(var1(l), var1(l')) -> eq2(l, l')
eq2(var1(l), apply2(t, s)) -> false
eq2(var1(l), lambda2(x, t)) -> false
eq2(apply2(t, s), var1(l)) -> false
eq2(apply2(t, s), apply2(t', s')) -> and2(eq2(t, t'), eq2(s, s'))
eq2(apply2(t, s), lambda2(x, t)) -> false
eq2(lambda2(x, t), var1(l)) -> false
eq2(lambda2(x, t), apply2(t, s)) -> false
eq2(lambda2(x, t), lambda2(x', t')) -> and2(eq2(x, x'), eq2(t, t'))
if3(true, var1(k), var1(l')) -> var1(k)
if3(false, var1(k), var1(l')) -> var1(l')
ren3(var1(l), var1(k), var1(l')) -> if3(eq2(l, l'), var1(k), var1(l'))
ren3(x, y, apply2(t, s)) -> apply2(ren3(x, y, t), ren3(x, y, s))
ren3(x, y, lambda2(z, t)) -> lambda2(var1(cons2(x, cons2(y, cons2(lambda2(z, t), nil)))), ren3(x, y, ren3(z, var1(cons2(x, cons2(y, cons2(lambda2(z, t), nil)))), t)))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].


The following pairs can be oriented strictly and are deleted.


EQ2(var1(l), var1(l')) -> EQ2(l, l')
The remaining pairs can at least be oriented weakly.

EQ2(apply2(t, s), apply2(t', s')) -> EQ2(t, t')
EQ2(apply2(t, s), apply2(t', s')) -> EQ2(s, s')
Used ordering: Polynomial interpretation [21]:

POL(EQ2(x1, x2)) = x1·x2   
POL(apply2(x1, x2)) = x1 + x2   
POL(var1(x1)) = 1 + x1 + x12   

The following usable rules [14] were oriented: none



↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
            ↳ QDPOrderProof
              ↳ QDP
                ↳ QDPOrderProof
                  ↳ QDP
                    ↳ QDPOrderProof
QDP
                        ↳ QDPOrderProof
          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

EQ2(apply2(t, s), apply2(t', s')) -> EQ2(t, t')
EQ2(apply2(t, s), apply2(t', s')) -> EQ2(s, s')

The TRS R consists of the following rules:

and2(true, y) -> y
and2(false, y) -> false
eq2(nil, nil) -> true
eq2(cons2(t, l), nil) -> false
eq2(nil, cons2(t, l)) -> false
eq2(cons2(t, l), cons2(t', l')) -> and2(eq2(t, t'), eq2(l, l'))
eq2(var1(l), var1(l')) -> eq2(l, l')
eq2(var1(l), apply2(t, s)) -> false
eq2(var1(l), lambda2(x, t)) -> false
eq2(apply2(t, s), var1(l)) -> false
eq2(apply2(t, s), apply2(t', s')) -> and2(eq2(t, t'), eq2(s, s'))
eq2(apply2(t, s), lambda2(x, t)) -> false
eq2(lambda2(x, t), var1(l)) -> false
eq2(lambda2(x, t), apply2(t, s)) -> false
eq2(lambda2(x, t), lambda2(x', t')) -> and2(eq2(x, x'), eq2(t, t'))
if3(true, var1(k), var1(l')) -> var1(k)
if3(false, var1(k), var1(l')) -> var1(l')
ren3(var1(l), var1(k), var1(l')) -> if3(eq2(l, l'), var1(k), var1(l'))
ren3(x, y, apply2(t, s)) -> apply2(ren3(x, y, t), ren3(x, y, s))
ren3(x, y, lambda2(z, t)) -> lambda2(var1(cons2(x, cons2(y, cons2(lambda2(z, t), nil)))), ren3(x, y, ren3(z, var1(cons2(x, cons2(y, cons2(lambda2(z, t), nil)))), t)))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].


The following pairs can be oriented strictly and are deleted.


EQ2(apply2(t, s), apply2(t', s')) -> EQ2(t, t')
EQ2(apply2(t, s), apply2(t', s')) -> EQ2(s, s')
The remaining pairs can at least be oriented weakly.
none
Used ordering: Polynomial interpretation [21]:

POL(EQ2(x1, x2)) = 1 + x1·x2   
POL(apply2(x1, x2)) = 1 + x1 + x1·x2 + x2   

The following usable rules [14] were oriented: none



↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
            ↳ QDPOrderProof
              ↳ QDP
                ↳ QDPOrderProof
                  ↳ QDP
                    ↳ QDPOrderProof
                      ↳ QDP
                        ↳ QDPOrderProof
QDP
                            ↳ PisEmptyProof
          ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

and2(true, y) -> y
and2(false, y) -> false
eq2(nil, nil) -> true
eq2(cons2(t, l), nil) -> false
eq2(nil, cons2(t, l)) -> false
eq2(cons2(t, l), cons2(t', l')) -> and2(eq2(t, t'), eq2(l, l'))
eq2(var1(l), var1(l')) -> eq2(l, l')
eq2(var1(l), apply2(t, s)) -> false
eq2(var1(l), lambda2(x, t)) -> false
eq2(apply2(t, s), var1(l)) -> false
eq2(apply2(t, s), apply2(t', s')) -> and2(eq2(t, t'), eq2(s, s'))
eq2(apply2(t, s), lambda2(x, t)) -> false
eq2(lambda2(x, t), var1(l)) -> false
eq2(lambda2(x, t), apply2(t, s)) -> false
eq2(lambda2(x, t), lambda2(x', t')) -> and2(eq2(x, x'), eq2(t, t'))
if3(true, var1(k), var1(l')) -> var1(k)
if3(false, var1(k), var1(l')) -> var1(l')
ren3(var1(l), var1(k), var1(l')) -> if3(eq2(l, l'), var1(k), var1(l'))
ren3(x, y, apply2(t, s)) -> apply2(ren3(x, y, t), ren3(x, y, s))
ren3(x, y, lambda2(z, t)) -> lambda2(var1(cons2(x, cons2(y, cons2(lambda2(z, t), nil)))), ren3(x, y, ren3(z, var1(cons2(x, cons2(y, cons2(lambda2(z, t), nil)))), t)))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
QDP

Q DP problem:
The TRS P consists of the following rules:

REN3(x, y, apply2(t, s)) -> REN3(x, y, t)
REN3(x, y, lambda2(z, t)) -> REN3(x, y, ren3(z, var1(cons2(x, cons2(y, cons2(lambda2(z, t), nil)))), t))
REN3(x, y, lambda2(z, t)) -> REN3(z, var1(cons2(x, cons2(y, cons2(lambda2(z, t), nil)))), t)
REN3(x, y, apply2(t, s)) -> REN3(x, y, s)

The TRS R consists of the following rules:

and2(true, y) -> y
and2(false, y) -> false
eq2(nil, nil) -> true
eq2(cons2(t, l), nil) -> false
eq2(nil, cons2(t, l)) -> false
eq2(cons2(t, l), cons2(t', l')) -> and2(eq2(t, t'), eq2(l, l'))
eq2(var1(l), var1(l')) -> eq2(l, l')
eq2(var1(l), apply2(t, s)) -> false
eq2(var1(l), lambda2(x, t)) -> false
eq2(apply2(t, s), var1(l)) -> false
eq2(apply2(t, s), apply2(t', s')) -> and2(eq2(t, t'), eq2(s, s'))
eq2(apply2(t, s), lambda2(x, t)) -> false
eq2(lambda2(x, t), var1(l)) -> false
eq2(lambda2(x, t), apply2(t, s)) -> false
eq2(lambda2(x, t), lambda2(x', t')) -> and2(eq2(x, x'), eq2(t, t'))
if3(true, var1(k), var1(l')) -> var1(k)
if3(false, var1(k), var1(l')) -> var1(l')
ren3(var1(l), var1(k), var1(l')) -> if3(eq2(l, l'), var1(k), var1(l'))
ren3(x, y, apply2(t, s)) -> apply2(ren3(x, y, t), ren3(x, y, s))
ren3(x, y, lambda2(z, t)) -> lambda2(var1(cons2(x, cons2(y, cons2(lambda2(z, t), nil)))), ren3(x, y, ren3(z, var1(cons2(x, cons2(y, cons2(lambda2(z, t), nil)))), t)))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.